require 'digest/sha1'
require 'paperclip'

class User < ActiveRecord::Base
 
  # Virtual attribute for the unencrypted password
  attr_accessor :password

  validates_presence_of     :login, :email, :role_user_id
  validates_presence_of     :password,                   :if => :password_required?
  validates_presence_of     :password_confirmation,      :if => :password_required?
  validates_length_of       :password, :within => 4..40, :if => :password_required?
  validates_confirmation_of :password,                   :if => :password_required?
  validates_length_of       :login,    :within => 3..40
  validates_length_of       :email,    :within => 3..100
  validates_uniqueness_of   :login, :case_sensitive => false
  before_save :encrypt_password
  
  has_attached_file :photo, :styles => { :small => "70x70",:normal => "200x200" },
                  :url  => "/assets/users/:id/:style/:basename.:extension",
                  :path => ":rails_root/public/assets/users/:id/:style/:basename.:extension"
  
  
  # prevents a user from submitting a crafted form that bypasses activation
  # anything else you want your user to change should be added here.
#  attr_accessible :login,:name, :email, :password, :password_confirmation

	
  belongs_to :usuario_cuenta 
	has_many :usuario_cuentas , :dependent => :destroy	


  has_one				:role_user
  belongs_to				:role_user

  has_one				:equipo
  belongs_to				:equipo

	has_many  		:reporte, :dependent => :destroy


	def self.hay_roles
		if RoleUser.find(:all) then 
				return true
	 	else
	  		return false
		end		
	end
	
  def self.search_all(search, page)
	  if search
    	paginate :per_page => 3, :page => page, :order => 'id',:conditions => ['name LIKE ?', "%#{search}%"]
  	else
			paginate :per_page => 3, :page => page, :order => 'id'
		end
	end
	
	def self.listas_roles()
		@role_ids = User.find(:all).collect(&:role_user_id) 
    @roles = RoleUser.find(:all, :conditions => ['id in (?)',@role_ids])   
	end

	def self.search_role(search, page, role_user_id)
		paginate :per_page => 3, :page => page, :order => 'id', :conditions => ['role_user_id = '+role_user_id]
	end

	def self.get_no_invitados()
		@users = User.find(:all)
		for user in @users
			if user.role_user.descripcion == 'Invitado' then
				@users.delete(user)
			end
		end			
		@users = @users.collect {|e| [ e.login, e.id ] }
	end

  # Authenticates a user by their login name and unencrypted password.  Returns the user or nil.
  def self.authenticate(login, password)
    u = find_by_login(login) # need to get the salt
    u && u.authenticated?(password) ? u : nil
  end

  # Encrypts some data with the salt.
  def self.encrypt(password, salt)
    Digest::SHA1.hexdigest("--#{salt}--#{password}--")
  end

  # Encrypts the password with the user salt
  def encrypt(password)
    self.class.encrypt(password, salt)
  end

  def authenticated?(password)
    crypted_password == encrypt(password)
  end

  def remember_token?
    remember_token_expires_at && Time.now.utc < remember_token_expires_at 
  end

  # These create and unset the fields required for remembering users between browser closes
  def remember_me
    remember_me_for 2.weeks
  end

  def remember_me_for(time)
    remember_me_until time.from_now.utc
  end

  def remember_me_until(time)
    self.remember_token_expires_at = time
    self.remember_token            = encrypt("#{email}--#{remember_token_expires_at}")
    save(false)
  end

  def forget_me
    self.remember_token_expires_at = nil
    self.remember_token            = nil
    save(false)
  end

  # Returns true if the user has just been activated.
  def recently_activated?
    @activated
  end

	protected
    # before filter 
    def encrypt_password
      return if password.blank?
      self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{login}--") if new_record?
      self.crypted_password = encrypt(password)
    end
      
    def password_required?
      crypted_password.blank? || !password.blank?
    end
    
    
end
